/**
 * Description:
 * Date: 2025-10-25
 * Time: 21:26
 */
public class Test {
    public static void main1(String[] args) {
        int a = 10;
        int b = 20;

        int sum = a + b;//30
        System.out.println(sum);
        sum = a - b;//-10
        System.out.println(sum);
    }

    public static void main2(String[] args) {
        int a = 10;
        int b = 20;

        int sum = a * b;
        System.out.println(sum);//200
    }

    public static void main3(String[] args) {
        int a = 10;
        int b = 20;

        //在java中，int / int 只会保留整数部分
        int sum = a / b;
        System.out.println(sum);//0 (0.5 --> 0)保留整数部分

        int c = 30;
        sum = c / b;
        System.out.println(sum);//1 (1.5 --> 1)保留整数部分

        //若想保留小数部分，则需操作数至少一个为浮点型
        //a*1.0,因为1.0是浮点数，发生类型提升，a的类型变为double类型，随即b也发生类型提升，变为double类型
        double ret = (a*1.0) / b;
        System.out.println(ret);//0.5

        //除数，也就是 / 右边的操作数不能为0，否则是语法错误，程序执行报错
        sum = a / 0;
        System.out.println(sum);//error
    }

    public static void main4(String[] args) {
        int a = 17;
        int b = 21;

        //a整除10的结果是：a除10后的余数
        int sum = a % 10;//17%10 --> 17/10 = 1...7,则7就是17%10的结果
        System.out.println(sum);//7

        sum = b % 10;
        System.out.println(sum);//1

        sum = b % a;//
        System.out.println(sum);//4  21/17 = 1...4,则(余数)4就是21%17的结果

        sum = a % 0;//整除数，也就是 % 右边的操作数不能为0，语法错误，程序执行时错误
        System.out.println(sum);//error
    }

    public static void main5(String[] args) {
        //增量运算符：此类型的运算符，最后的运算结果会返回给左边的操作数
        int a = 1;
        a += 2;//相当于 a = a + 2;
        System.out.println(a);//3

        int b = 1;
        b -= 2;//相当于 b= b - 2;
        System.out.println(b);//-1

        int c = 1;
        int d = 10;
        c *= d;//相当于 c = c * d --> c = 1 * 10 = 10;
        System.out.println(c);//10

        int e = 10;
        e /= 2;//相当于 e = e / 2; (10 / 2 = 5)
        System.out.println(e);//5

        int f = 1;
        f %= 10;//相当于 e = e % 10; (1 % 10 = 0...1)
        System.out.println(f);//1
    }

    public static void main6(String[] args) {
        int a = 1;
        a++;//[后置++]，表示给变量a的值+1，此时a为2
        System.out.println(a);//2

        //自增运算符 ++，分[前置++] 和 [后置++]
        a = 1;
        a++;//此时a的值已经被+1过，从结果上来说，可以表示为a = a + 1，仅限单独使用时能这样表示;

        //[前置++]是先使用变量a，等有关变量a的表达式结束之后，才会对变量a进行++
        System.out.println(a++);//输出2，然后变量a再进行+1操作
        System.out.println(a);//输出3

        a = 1;
        //[后置++]是先将变量a值进行+1，然后再执行有关a的表达式
        System.out.println(++a);

        //对比：
        int b = 1;
        int c = 1;
        System.out.println(b++);//1  先使用b再+1
        System.out.println(++c);//2  先+1再使用b

        //自减操作符--，也分前置-- 和 后置--
        int d = 2;
        d--;//先使用d的值，再减1
        System.out.println(d);//1

        //其余的用法跟自增操作符++一样，只是一个使变量的值+1，一个变量的值-1
    }

    public static void main7(String[] args) {
        int a = 10;
        int b = 20;

        //在java中，=表示复制，与在数学中表示的含义不同
        //在java中，== 才表示相等
        System.out.println(a == b);//false  10 == 20，10等于20是错的，返回false

        System.out.println(a != b);//true   10 != 20，10不等于20是对的，返回true

        System.out.println(a < b);//true    10 < 20， 10小于20是对的，返回true

        System.out.println(a > b);//false   10 > 20， 10大于20是错的，返回false

        System.out.println(a <= b);//true   10 <= 20， 10小于或等于20是对的，返回true

        System.out.println(a >= b);//false  10 >= 20， 10大于或等于20是错的，返回false
    }

    public static void main8(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println(a == 10 && b == 20);//左为真 且 右为真，则结果为真true

        System.out.println(a == 10 && b == 200);//左为真 且 右为假，则结果为假false

        System.out.println(a == 100 && b == 20);//左为假 且 右为真，则结果为假false

        System.out.println(a == 100 && b == 200);//左为假 且 右为假，则结果为假false
    }

    public static void main9(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println(a == 10 || b == 20);//左为真 且 右为真，则结果为真true

        System.out.println(a == 10 || b == 200);//左为真 且 右为假，则结果为真true

        System.out.println(a == 100 || b ==20);//左为假 且 右为真，则结果为真true

        System.out.println(a == 100 || b == 200);//左为假 且 右为假，则结果为真false
    }

    public static void main10(String[] args) {
        int a = 10;

        System.out.println(!(a == 10));//表达式为真，则结果为假false

        System.out.println(!(a == 100));//表达式为假，则结果为真true
    }

    public static void main11(String[] args) {
        //逻辑与&&的判断是两边真结果才为真，有一个假结果解释假

        //程序在下方代码的执行顺序是从左到右的，左边表达式的值为false
        //       则整个表达式的结果一定是false，右边表达式不会被执行
        //右边表达式是10 / 0，在计算时程序会报错
        //    此时程序正常输出false，说明10 / 0 == 10没有真正被执行
        System.out.println(10 > 20 && 10 / 0 == 10);//false

        //左边表达式为真，不能确定整个表达式是否为真，执行右边表达式
        //    右边表达式出语法错误，程序报错
        System.out.println(10 < 20 && 10 / 0 == 10);//error
    }

    public static void main12(String[] args) {
        //逻辑与||的判断是有真则真，全为假则假

        //先执行左边表达式，结果为真，则整个表达式都为真，程序结束，右边表达式不执行
        System.out.println(10 < 20 || 10 / 0 == 10);
    }

    public static void main13(String[] args) {
        int a = 5;
        int b = 14;
        //按位与&：如果两个二进制位都是1，则结果为1，否则为0
        //以8位二进制位进行计算

        //整数的正码、反码、补码都一样
        //(以补码的形式进行运算)

        //5的二进制： 0000 0101
        //14的二进制：0000 1110
        //进行&运算： 0000 0100 --> 4  (有0为0，全1为1)

        System.out.println(a & b);//4
    }

    public static void main14(String[] args) {
        int a = 5;
        int b = 14;
        //按位或|：如果两个二进制位都是0，则为0，否则为1。(有1则1，全0为0)
        //以8位二进制位进行计算

        //(以补码的形式进行运算)
        //5的二进制： 0000 0101
        //14的二进制：0000 1110
        //进行|运算： 0000 1111 --> 15 (有1则1，全0为0)

        System.out.println(a | b);//15
    }

    public static void main15(String[] args) {
        int a = 5;
        //按位取反：二进制位0变1，1变0
        //以8位二进制位进行计算

        //(以补码的形式存在)
        //5的二进制： 0000 0101
        //进行~运算： 1111 1010 --> -6的补码 (0变1，1变0)

        System.out.println(~a);//-6
    }

    public static void main16(String[] args) {
        int a = 5;
        int b = 14;
        //按位异或^：如果两个二进制位相同，则结果为0，相异为1。(相同为0，相异为1)
        //以8位二进制位进行计算

        //(以补码的形式进行运算)
        //5的二进制： 0000 0101
        //14的二进制：0000 1110
        //进行^运算： 0000 1011 --> 11  (相同为0，相异为1)

        System.out.println(a ^ b);//11
    }

    public static void main17(String[] args) {
        int a = 1;
        //左移<<：二进制位最左侧不要，在最右侧补0
        //以省略的32位二进制位进行计算

        //左移 1 位  (以补码的形式进行运算)
        //1的二进制：  0000 ....  0001
        //进行<<运算：  000  .... 00010 --> 2

        System.out.println(a << 1);//2  (左移 1 位)
    }

    public static void main18(String[] args) {
        int a = 10;
        //右移>>：二进制的最右侧位不要，在最左侧位补符号位(正数补0，负数补1)
        //以省略的32位二进制位进行计算

        //右移 1 位  (以补码的形式进行运算)
        //10的二进制： 0000 .... 1010
        //进行>>运算：00000 ....  101 --> 5

        System.out.println( a>> 1);//5  (右移 1 位)
    }

    public static void main19(String[] args) {
        int a = 1;
        int b = -1;
        //无符号右移>>>:二进制的最右侧位不要，在最左侧位统一补0
        //以省略的32位二进制位进行计算

        //无符号右移 1 位  (以补码的形式进行运算)
        //1的二进制：   0000 .... 0001
        //进行>>>运算：00000 .... 000 --> 0
        System.out.println(a >>> 1);//0

        //-1的二进制：  1111 ....  1111
        //进行>>>运算: 01111 .... 111 -->2147483647
        //负数的符号位变成0，变成正数，正数的原码和补码一样
        System.out.println(b >>> 1);//2147483647

        //几乎所有的负数进行无符号右移都会变为很大的正数
    }

    public static void main(String[] args) {
        //布尔表达式：10 > 20 为false，则整个表达式的值为表达式3,即20
        //表达式2 和 表达式3 的类型都是int
        int a = 10 > 20? 10:20;
        System.out.println(a);//20

        //布尔表达式：10 < 20 为true，则整个表达式的值为 表达式2,即 10
        //表达式2 和 表达式3 的类型都是int
        int b = 10 < 20? 10:20;
        System.out.println(b);//10

        //double 和 int，int类型能转换成接收条件运算符结果的double类型
        double c = 10 < 20? 1.0:20;
        System.out.println(b);

        //"20"是引用类型，与double类型(基本数据类型)没有自动类型提升的机制，也无法相互兼容
        //但可以使用包装类的Double.parseDouble()显示强转为double类型，但在条件运算符中行不通
        //double d = 10 < 20? 1.0:"20";

        //这里大概是将 int类型的10进行装箱成了:(包装类)Integer类型
        // Integer 与 String 都是对象类型，有共同的父类Object，故能输出
        System.out.println(10 > 20 ? 10 : "string");//string
        System.out.println(10 < 20 ? 10 : "string");//10
    }

}
